package com.un.ebs.core.util;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串帮助类
 *
 * @email 496382223@qq.com
 * @author:Lijj
 * @date: 2019/7/24
 */
public class StringUtils {
    /**
     * 判断字符串是否为null或者为空字符串
     *
     * @param value
     * @return
     */
    public static boolean isNullOrEmpty(String value) {
        return value == null || "".equals(value) || "null".equals(value);
    }


    /**
     * 判断List对像是否为空。
     *
     * @param list
     * @return
     */
    public static <T> boolean isNullOrEmpty(List<? super T> list) {
        if (list == null) {
            return true;
        }
        return list.size() <= 0;
    }


    /**
     * 在字符串中按模式找到字段名，并用实例中的值替换
     *
     * @param str
     * @param prefix
     * @param suffix
     * @param obj
     * @return
     */
    public static String valueReplace(String str, String prefix, String suffix, Object obj) {
        if (isNullOrEmpty(str)) {
            return null;
        }
        if (isNullOrEmpty(prefix) || isNullOrEmpty(suffix)) {
            return str;
        }
        if (obj == null) {
            return str;
        }

        List<String> fields = patternValue(str, prefix, suffix);
        for (String field : fields) {
            Object value = RefUtils.getFieldValueByName(field, obj);
            if (value == null) {
                continue;
            }
            String old = (prefix + field + suffix).replace("\\", "");
            str = str.replace(old, value.toString());
        }
        return str;
    }

    /**
     * 在给定的数组中，找出与obj相匹配的字段名和相应的实例值，并返回
     * <p>
     * 用于模板消息中各参数值的配置："{{first}}={custId}"
     *
     * @param args 带有自定义字段名称、对象字段名表达式数组
     * @param obj  要查询的实例值
     * @return 自定义字段名称、包含实例值的文本
     */
    public static Map<String, String> splitTemplate(String[] args, Object obj) {
        System.out.println("====================================================================");
        System.out.println("                           配置解析                                  ");
        Map<String, String> maps = new HashMap<>();
        for (int i = 0; i < args.length; i++) {
            //取出参数名称
            String name = args[i].split("=")[0].replace("{", "").replace("}", "");

            //取出值的完整字符
            if (args[i].split("=").length < 2) {
                continue;
            }
            String value = args[i].split("=")[1];
            //找出其中的字段
            List<String> fieldValues = StringUtils.patternValue(value, "\\{", "\\}");
            //替换字段为具体值
            for (String str : fieldValues) {
                Object instanceValue = RefUtils.getFieldValueByName(str, obj);
                if (instanceValue == null) {
                    continue;
                }
                String strValue = "";
                if (instanceValue.getClass().isAssignableFrom(Date.class)) {
                    strValue = DateUtils.formatDate((Date) instanceValue, "yyyy-MM-dd hh:ss");
                } else {
                    strValue = instanceValue.toString();
                }
                value = value.replace("{", "").replace("}", "").replace(str, strValue);
            }
            System.out.println(String.format("%s : %s", name, value));
            maps.put(name, value);
        }
        System.out.println("                                                                    ");
        System.out.println("                                end                                 ");
        System.out.println("====================================================================");
        return maps;
    }


    /**
     * 在给定的字符串中，按指定的前缀和后缀，返回符合此模式的所有值
     *
     * @param str
     * @param prefix 对于特殊字段需要做转义，如"{"符号，应表示为"\\{"
     * @return
     */
    public static List<String> patternValue(String str, String prefix, String suffix) {
        List<String> list = new ArrayList<String>();
        String regx = prefix + "(.*?)" + suffix;

        // 匹配的模式
        Pattern pattern = Pattern.compile(regx);
        Matcher m = pattern.matcher(str);
        while (m.find()) {
            int i = 1;
            list.add(m.group(i));
            i++;
        }
        return list;
    }

    /**
     * <br>　　　　　2019年1月16日已知
     * 中国电信号段
     * 133,149,153,173,174,177,180,181,189,199
     * 中国联通号段
     * 130,131,132,145,146,155,156,166,175,176,185,186
     * 中国移动号段
     * 134(0-8),135,136,137,138,139,147,148,150,151,152,157,158,159,165,178,182,183,184,187,188,198
     * 上网卡专属号段（用于上网和收发短信，不能打电话）
     * 如中国联通的是145
     * 虚拟运营商
     * 电信：1700,1701,1702
     * 移动：1703,1705,1706
     * 联通：1704,1707,1708,1709,171
     * 卫星通信： 1349 <br>　　　　　未知号段：141、142、143、144、154
     *
     * @param value
     * @return
     */
    public static boolean isMobile(String value) {
        Pattern p = null;
        Matcher m = null;
        boolean b = false;
        String s2 = "^[1](([3|5|8][\\d])|([4][4,5,6,7,8,9])|([6][2,5,6,7])|([7][^9])|([9][1,8,9]))[\\d]{8}$";// 验证手机号
        if (!isNullOrEmpty(value)) {
            p = Pattern.compile(s2);
            m = p.matcher(value);
            b = m.matches();
        }
        return b;
    }

    public static String randomCode(int len) {
        Integer rand = ((int) (Math.random() * (1000 - 1) + 1));
        String id = "000" + rand.toString();
        Integer idHash = Math.abs(UUID.randomUUID().hashCode());

        return idHash.toString().substring(idHash.toString().length() - (len - 3)) + id.substring(id.length() - 3);
    }

    public static String randStr(int n) {
        return new Random()
                .ints(97, 122 + 1)
                .limit(n)
                .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
                .toString();
    }

    public static boolean isNumeric(String str) {
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }
}
